# Configure Plotly to properly render in HTML exports
import plotly.io as pio

# Set the renderer for notebook display
pio.renderers.default = "notebook"

# Configure global theme for consistent appearance
pio.templates.default = "plotly_white"

import os
# Set environment variable to disable oneDNN optimizations to avoid numerical differences
os.environ['TF_ENABLE_ONEDNN_OPTS'] = '0'

# Import tqdm for progress bars
from tqdm.notebook import tqdm

import pandas as pd
import glob

# Read all CSV files from dataset/Flipkart directory with glob
csv_files = glob.glob('dataset/Flipkart/flipkart*.csv')

# Import the CSV files into a dataframe
df = pd.read_csv(csv_files[0])

# Display first few rows
df.head()

from src.classes.analyze_value_specifications import SpecificationsValueAnalyzer

analyzer = SpecificationsValueAnalyzer(df)
value_analysis = analyzer.get_top_values(top_keys=5, top_values=5)
value_analysis

# Create a radial icicle chart to visualize the top values
fig = analyzer.create_radial_icicle_chart(top_keys=10, top_values=20)
fig.show()

from src.classes.analyze_category_tree import CategoryTreeAnalyzer

# Create analyzer instance with your dataframe
category_analyzer = CategoryTreeAnalyzer(df)

# Create and display the radial category chart
fig = category_analyzer.create_radial_category_chart(max_depth=9)
fig.show()

# Import TextPreprocessor class
from src.classes.preprocess_text import TextPreprocessor

# Create processor instance
processor = TextPreprocessor()

# 1. Demonstrate functions with a clear example sentence
print("🔍 TEXT PREPROCESSING DEMONSTRATION")
print("=" * 50)

test_sentence = "To be or not to be, that is the question: whether 'tis nobler in the mind to suffer the slings and arrows of outrageous fortune, or to take arms against a sea of troubles and, by opposing, end them?"

print(f"Original: '{test_sentence}'")
print(f"Tokenized: {processor.tokenize_sentence(test_sentence)}")
print(f"Stemmed: '{processor.stem_sentence(test_sentence)}'")
print(f"Lemmatized: '{processor.lemmatize_sentence(test_sentence)}'")
print(f"Fully preprocessed: '{processor.preprocess(test_sentence)}'")

# 2. Process the DataFrame columns efficiently
print("\n🔄 APPLYING TO DATASET")
print("=" * 50)

# Apply preprocessing to product names
df['product_name_lemmatized'] = df['product_name'].apply(processor.preprocess)
df['product_name_stemmed'] = df['product_name'].apply(processor.stem_text)
df['product_category'] = df['product_category_tree'].apply(processor.extract_top_category)

# 3. Show a few examples of the transformations
print("\n📋 TRANSFORMATION EXAMPLES")
print("=" * 50)
comparison_data = []

for i in range(min(5, len(df))):
    original = df['product_name'].iloc[i]
    lemmatized = df['product_name_lemmatized'].iloc[i]
    stemmed = df['product_name_stemmed'].iloc[i]
    
    # Truncate long examples for display
    max_len = 50
    orig_display = original[:max_len] + ('...' if len(original) > max_len else '')
    lem_display = lemmatized[:max_len] + ('...' if len(lemmatized) > max_len else '')
    stem_display = stemmed[:max_len] + ('...' if len(stemmed) > max_len else '')
    
    comparison_data.append({
        'Original': orig_display,
        'Lemmatized': lem_display,
        'Stemmed': stem_display
    })

comparison_df = pd.DataFrame(comparison_data)
display(comparison_df)

# 4. Print summary statistics
print("\n📊 PREPROCESSING STATISTICS")
print("=" * 50)
total_words_before = df['product_name'].str.split().str.len().sum()
total_words_lemmatized = df['product_name_lemmatized'].str.split().str.len().sum()
total_words_stemmed = df['product_name_stemmed'].str.split().str.len().sum()

lem_reduction = ((total_words_before - total_words_lemmatized) / total_words_before) * 100
stem_reduction = ((total_words_before - total_words_stemmed) / total_words_before) * 100

print(f"Total words before processing: {total_words_before:,}")
print(f"Words after lemmatization: {total_words_lemmatized:,} ({lem_reduction:.1f}% reduction)")
print(f"Words after stemming: {total_words_stemmed:,} ({stem_reduction:.1f}% reduction)")
print(f"Unique categories extracted: {df['product_category'].nunique()}")

# Display additional analysis
print("\n📈 WORD REDUCTION ANALYSIS")
print("=" * 50)
print(f"Total words removed by lemmatization: {total_words_before - total_words_lemmatized:,}")
print(f"Total words removed by stemming: {total_words_before - total_words_stemmed:,}")
print(f"Stemming vs. lemmatization difference: {total_words_lemmatized - total_words_stemmed:,} words")
print(f"Stemming provides additional {stem_reduction - lem_reduction:.1f}% reduction over lemmatization")

# Show average words per product
avg_words_before = df['product_name'].str.split().str.len().mean()
avg_words_lemmatized = df['product_name_lemmatized'].str.split().str.len().mean()
avg_words_stemmed = df['product_name_stemmed'].str.split().str.len().mean()

print(f"\nAverage words per product name:")
print(f"  - Before preprocessing: {avg_words_before:.1f}")
print(f"  - After lemmatization: {avg_words_lemmatized:.1f}")
print(f"  - After stemming: {avg_words_stemmed:.1f}")

🔍 TEXT PREPROCESSING DEMONSTRATION
==================================================
Original: 'To be or not to be, that is the question: whether 'tis nobler in the mind to suffer the slings and arrows of outrageous fortune, or to take arms against a sea of troubles and, by opposing, end them?'
Tokenized: ['To', 'be', 'or', 'not', 'to', 'be', ',', 'that', 'is', 'the', 'question', ':', 'whether', "'t", 'is', 'nobler', 'in', 'the', 'mind', 'to', 'suffer', 'the', 'slings', 'and', 'arrows', 'of', 'outrageous', 'fortune', ',', 'or', 'to', 'take', 'arms', 'against', 'a', 'sea', 'of', 'troubles', 'and', ',', 'by', 'opposing', ',', 'end', 'them', '?']
Stemmed: 'to be or not to be that is the question whether ti nobler in the mind to suffer the sling and arrow of outrag fortun or to take arm against a sea of troubl and by oppos end them'

Lemmatized: 'to be or not to be that is the question whether ti nobler in the mind to suffer the sling and arrow of outrageous fortune or to take arm against a sea of trouble and by opposing end them'
Fully preprocessed: 'question whether ti nobler mind suffer sling arrow outrageous fortune take arm sea trouble opposing end'

🔄 APPLYING TO DATASET
==================================================

📋 TRANSFORMATION EXAMPLES
==================================================

📊 PREPROCESSING STATISTICS
==================================================
Total words before processing: 7,631
Words after lemmatization: 6,512 (14.7% reduction)
Words after stemming: 6,512 (14.7% reduction)
Unique categories extracted: 7

📈 WORD REDUCTION ANALYSIS
==================================================
Total words removed by lemmatization: 1,119
Total words removed by stemming: 1,119
Stemming vs. lemmatization difference: 0 words
Stemming provides additional 0.0% reduction over lemmatization

Average words per product name:
  - Before preprocessing: 7.3
  - After lemmatization: 6.2
  - After stemming: 6.2

from src.classes.encode_text import TextEncoder

# Initialize encoder once
encoder = TextEncoder()

# Fit and transform product names
encoding_results = encoder.fit_transform(df['product_name_lemmatized'])


# For a Bag of Words cloud
bow_cloud = encoder.plot_word_cloud(use_tfidf=False, max_words=100, colormap='plasma')
bow_cloud.show()

# Create and display BoW plot
bow_fig = encoder.plot_bow_features(threshold=0.98)
print("\nBag of Words Feature Distribution:")
bow_fig.show()

Bag of Words Feature Distribution:

# For a TF-IDF word cloud
word_cloud = encoder.plot_word_cloud(use_tfidf=True, max_words=100, colormap='plasma')
word_cloud.show()

# Create and display TF-IDF plot
tfidf_fig = encoder.plot_tfidf_features(threshold=0.98)
print("\nTF-IDF Feature Distribution:")
tfidf_fig.show()

TF-IDF Feature Distribution:

# Show comparison
comparison_fig = encoder.plot_feature_comparison(threshold=0.98)
print("\nFeature Comparison:")
comparison_fig.show()

# Plot scatter comparison
scatter_fig = encoder.plot_scatter_comparison()
print("\nTF-IDF vs BoW Scatter Comparison:")
scatter_fig.show()

Feature Comparison:

TF-IDF vs BoW Scatter Comparison:

from src.classes.reduce_dimensions import DimensionalityReducer

# Initialize reducer
reducer = DimensionalityReducer()


# Apply dimensionality reduction to TF-IDF matrix of product names
print("\nApplying PCA to product name features...")
pca_results = reducer.fit_transform_pca(encoder.tfidf_matrix)
pca_fig = reducer.plot_pca(labels=df['product_category'])
pca_fig.show()

Applying PCA to product name features...

print("\nApplying t-SNE to product name features...")
tsne_results = reducer.fit_transform_tsne(encoder.tfidf_matrix)
tsne_fig = reducer.plot_tsne(labels=df['product_category'])
tsne_fig.show()

Applying t-SNE to product name features...

# Create silhouette plot for categories
print("\nGenerating silhouette plot for product categories...")
silhouette_fig = reducer.plot_silhouette(
    encoder.tfidf_matrix, 
    df['product_category']
)
silhouette_fig.show()

Generating silhouette plot for product categories...

# Create intercluster distance visualization
print("\nGenerating intercluster distance visualization...")
distance_fig = reducer.plot_intercluster_distance(
    encoder.tfidf_matrix,
    df['product_category']
)
distance_fig.show()

Generating intercluster distance visualization...

# Perform clustering on t-SNE results and evaluate against true categories
clustering_results = reducer.evaluate_clustering(
    encoder.tfidf_matrix,
    df['product_category'],
    n_clusters=7,
    use_tsne=True
)

# Get the dataframe with clusters
df_tsne = clustering_results['dataframe']

# Print the ARI score
print(f"Adjusted Rand Index: {clustering_results['ari_score']:.4f}")


# Create a heatmap visualization
heatmap_fig = reducer.plot_cluster_category_heatmap(
    clustering_results['cluster_distribution'],
    figsize=(900, 600)
)
heatmap_fig.show()

Clustering into 7 clusters...
Adjusted Rand Index: 0.3206

import os
import ssl
import certifi

os.environ['REQUESTS_CA_BUNDLE'] = certifi.where()
os.environ['SSL_CERT_FILE'] = certifi.where()


# Import the advanced embeddings class
from src.classes.advanced_embeddings import AdvancedTextEmbeddings

# Initialize the advanced embeddings class
adv_embeddings = AdvancedTextEmbeddings()

# Word2Vec Implementation
print("\n### Word2Vec Implementation")
word2vec_embeddings = adv_embeddings.fit_transform_word2vec(df['product_name_lemmatized'])
word2vec_results = adv_embeddings.compare_with_reducer(reducer, df['product_category'])

# Display Word2Vec visualizations
print("\nWord2Vec PCA Visualization:")
word2vec_results['pca_fig'].show()

print("\nWord2Vec t-SNE Visualization:")
word2vec_results['tsne_fig'].show()

print("\nWord2Vec Silhouette Analysis:")
word2vec_results['silhouette_fig'].show()

print("\nWord2Vec Cluster Analysis:")
print(f"Adjusted Rand Index: {word2vec_results['clustering_results']['ari_score']:.4f}")
word2vec_results['heatmap_fig'].show()

2025-12-28 23:16:57.650138: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:467] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered
WARNING: All log messages before absl::InitializeLog() is called are written to STDERR
E0000 00:00:1766963817.667443   27854 cuda_dnn.cc:8579] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered
E0000 00:00:1766963817.675649   27854 cuda_blas.cc:1407] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered
W0000 00:00:1766963817.695817   27854 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.
W0000 00:00:1766963817.695845   27854 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.
W0000 00:00:1766963817.695847   27854 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.
W0000 00:00:1766963817.695849   27854 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.
2025-12-28 23:16:57.702667: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.
To enable the following instructions: AVX2 AVX_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.

### Word2Vec Implementation

Clustering into 7 clusters...

Word2Vec PCA Visualization:

Word2Vec t-SNE Visualization:

Word2Vec Silhouette Analysis:

Word2Vec Cluster Analysis:
Adjusted Rand Index: 0.3635

# BERT Embeddings
print("\n### BERT Embeddings")
bert_embeddings = adv_embeddings.fit_transform_bert(df['product_name_lemmatized'])
bert_results = adv_embeddings.compare_with_reducer(reducer, df['product_category'])

# Display BERT visualizations
print("\nBERT PCA Visualization:")
bert_results['pca_fig'].show()

print("\nBERT t-SNE Visualization:")
bert_results['tsne_fig'].show()

print("\nBERT Silhouette Analysis:")
bert_results['silhouette_fig'].show()

print("\nBERT Cluster Analysis:")
print(f"Adjusted Rand Index: {bert_results['clustering_results']['ari_score']:.4f}")
bert_results['heatmap_fig'].show()

### BERT Embeddings

Clustering into 7 clusters...

BERT PCA Visualization:

BERT t-SNE Visualization:

BERT Silhouette Analysis:

BERT Cluster Analysis:
Adjusted Rand Index: 0.4003

# Universal Sentence Encoder
print("\n### Universal Sentence Encoder")
use_embeddings = adv_embeddings.fit_transform_use(df['product_name_lemmatized'])
use_results = adv_embeddings.compare_with_reducer(reducer, df['product_category'])

# Display USE visualizations
print("\nUSE PCA Visualization:")
use_results['pca_fig'].show()

print("\nUSE t-SNE Visualization:")
use_results['tsne_fig'].show()

print("\nUSE Silhouette Analysis:")
use_results['silhouette_fig'].show()

print("\nUSE Cluster Analysis:")
print(f"Adjusted Rand Index: {use_results['clustering_results']['ari_score']:.4f}")
use_results['heatmap_fig'].show()

### Universal Sentence Encoder
   📦 Using cached model directory: /app/cache/use_model
   ⏳ Loading Universal Sentence Encoder (this is a one-time download)...

2025-12-28 23:17:19.233247: E external/local_xla/xla/stream_executor/cuda/cuda_platform.cc:51] failed call to cuInit: INTERNAL: CUDA error: Failed call to cuInit: UNKNOWN ERROR (303)

   ✅ Model loaded successfully!

Clustering into 7 clusters...

USE PCA Visualization:

USE t-SNE Visualization:

USE Silhouette Analysis:

USE Cluster Analysis:
Adjusted Rand Index: 0.6433

from src.scripts.plot_ari_comparison import ari_comparison

# Collect ARI scores for comparison
ari_scores = {
    'TF-IDF': clustering_results['ari_score'],
    'Word2Vec': word2vec_results['clustering_results']['ari_score'],
    'BERT': bert_results['clustering_results']['ari_score'],
    'Universal Sentence Encoder': use_results['clustering_results']['ari_score']
}

# Create and display visualization
comparison_fig = ari_comparison(ari_scores)
comparison_fig.show()

import os
from src.classes.image_processor import ImageProcessor

# Initialize the image processor
image_processor = ImageProcessor(target_size=(224, 224), quality_threshold=0.8)

# Ensure sample images exist (creates them if directory doesn't exist)
image_dir = 'dataset/Flipkart/Images'
image_info = image_processor.ensure_sample_images(image_dir, num_samples=20)
print(f"📁 Found {image_info['count']} images in dataset")

# Process images (limit for demonstration)
image_paths = [os.path.join(image_dir, img) for img in image_info['available_images']]
max_images = min(1050, len(image_paths))
print(f"🖼️ Processing {max_images} images for feasibility study...")

# Process the images
processing_results = image_processor.process_image_batch(image_paths[:max_images])

# Create feature matrix from basic features
basic_feature_matrix, basic_feature_names = image_processor.create_feature_matrix(
    processing_results['basic_features']
)

# Analyze feature quality
feature_analysis = image_processor.analyze_features_quality(
    basic_feature_matrix, basic_feature_names
)

# Store results for later use
image_features_basic = basic_feature_matrix
image_processing_success = processing_results['summary']['success_rate']

# Create and display processing dashboard
processing_dashboard = image_processor.create_processing_dashboard(processing_results)
processing_dashboard.show()

📁 Found 1050 images in dataset
🖼️ Processing 1050 images for feasibility study...
Processing 1050 images...

Processing complete!
Success rate: 100.0%
Successful: 1050
Failed: 0
Created feature matrix: (1050, 208)
Feature names: 208
Created feature matrix: (1050, 208)
Feature names: 208

from src.scripts.plot_features_v2 import build_processing_dashboard

dashboard = build_processing_dashboard(processing_results)
dashboard.show()

from src.scripts.plot_basic_image_feature_extraction import run_basic_feature_demo

# Use processed images from Section 5
processed_images = processing_results['processed_images']
print(f"Using {len(processed_images)} processed images from Section 5")

demo = run_basic_feature_demo(processed_images, sample_size=10, random_seed=42)
demo['figure'].show()
print(demo['summary'])

Using 1050 processed images from Section 5
🔄 Extracting basic image features from 10 images...

✅ Feature extraction complete!

📊 Feature Extraction Summary:
   Images processed: 10
   Combined feature matrix: (10, 290)
   Feature types: 5

   🎯 Feature dimensions breakdown:
      SIFT: 128 dims (44.1%)
      LBP: 10 dims (3.4%)
      GLCM: 16 dims (5.5%)
      Gabor: 36 dims (12.4%)
      Patches: 100 dims (34.5%)

✅ Feature extraction visualization complete.
   📊 Total dimensions: 290
   🖼️ Images analyzed: 10

{'images_processed': 10, 'feature_matrix_shape': (10, 290), 'total_features': 290, 'feature_types': ['SIFT', 'LBP', 'GLCM', 'Gabor', 'Patches']}

from src.classes.vgg16_extractor import VGG16FeatureExtractor

# Initialize the VGG16 feature extractor
vgg16_extractor = VGG16FeatureExtractor(
    input_shape=(224, 224, 3),
    layer_name='block5_pool'
)

# Use processed images from Section 5 or create synthetic data
processed_images = processing_results['processed_images']
print(f"Using {len(processed_images)} processed images from Section 5")

# Extract deep features using VGG16
print("Extracting VGG16 features...")
deep_features = vgg16_extractor.extract_features(processed_images, batch_size=8)

# Find optimal number of PCA components
optimal_components, elbow_fig = vgg16_extractor.find_optimal_pca_components(
    deep_features,
    max_components=500, 
    step_size=50
)

# Display the elbow plot
elbow_fig.show()

# Apply dimensionality reduction
print("Applying PCA dimensionality reduction...")
deep_features_pca, pca_info, scaler_deep = vgg16_extractor.apply_dimensionality_reduction(
    deep_features, n_components=150, method='pca'
)

# Apply t-SNE for visualization
print("Applying t-SNE for visualization...")
deep_features_tsne, tsne_info, _ = vgg16_extractor.apply_dimensionality_reduction(
    deep_features_pca, n_components=2, method='tsne'
)

# Perform clustering
print("Performing clustering analysis...")
clustering_results = vgg16_extractor.perform_clustering(
    deep_features_pca, n_clusters=None, cluster_range=(2, 7)
)

# Store results for later sections
image_features_deep = deep_features_pca
optimal_clusters = clustering_results['n_clusters']
final_silhouette = clustering_results['silhouette_score']
feature_times = vgg16_extractor.processing_times

# Create analysis dashboard
print("Creating VGG16 analysis dashboard...")
vgg16_dashboard = vgg16_extractor.create_analysis_dashboard(
    deep_features, deep_features_pca, clustering_results, feature_times, pca_info=pca_info
)
vgg16_dashboard.show()

Initializing VGG16 model...

Model initialized: Using layer 'block5_pool' for feature extraction
Using 1050 processed images from Section 5
Extracting VGG16 features...

Features extracted: Shape=(1050, 25088)
🔍 Finding optimal number of PCA components...

Testing 10 different component counts...

✅ Optimal number of components: 50

Applying PCA dimensionality reduction...

Applying PCA to reduce dimensions from 25088 to 150...

PCA completed: 45.00% of variance preserved
Applying t-SNE for visualization...
Applying t-SNE to reduce dimensions to 2...
Warning: t-SNE on 1050 samples may take a long time.

t-SNE completed
Performing clustering analysis...
Finding optimal number of clusters in range (2, 7)...

Optimal number of clusters: 5 (silhouette score: 0.083)
Performing KMeans clustering with 5 clusters...
Clustering completed: 5 clusters, silhouette score: 0.083
Creating VGG16 analysis dashboard...

# Single method call that handles everything: ARI calculation, t-SNE visualization, and comparison
vgg16_analysis_results = vgg16_extractor.compare_with_categories(
    df=df,
    tsne_features=deep_features_tsne,
    clustering_results=clustering_results
)

# Extract results for use in overall comparisons
vgg16_ari = vgg16_analysis_results['ari_score']

# Add to comparison data for overall visualization
if 'ari_scores' not in globals():
    ari_scores = {}
ari_scores['VGG16 Deep Features'] = vgg16_ari

🔍 VGG16 Analysis: Comparing clustering with real product categories...
📊 VGG16 processed 1050 images
📋 Extracted 1050 categories
📂 Unique categories: 7
🎯 Adjusted Rand Index(ARI): -0.0006
🔗 Cluster quality (Silhouette): 0.083
📊 Number of clusters: 5
💡 Interpretation: Poor alignment

🏷️ Category distribution:
   Baby Care: 150 images
   Beauty and Personal Care: 150 images
   Computers: 150 images
   Home Decor & Festive Needs: 150 images
   Home Furnishing: 150 images
   Kitchen & Dining: 150 images
   Watches: 150 images

📊 Creating side-by-side comparison: Real Categories vs VGG16 Clusters...
🔍 VGG16 Side-by-Side Comparison:

from src.classes.swift_extractor import SWIFTFeatureExtractor

# Initialize the SWIFT feature extractor
swift_extractor = SWIFTFeatureExtractor(
    model_name='ViT-B/32',  # CLIP model
    device=None  # Auto-detect GPU/CPU
)

# Extract features from the same images used for VGG16
swift_features = swift_extractor.extract_features(processed_images, batch_size=16)

# Find optimal number of PCA components
optimal_components, elbow_fig = swift_extractor.find_optimal_pca_components(
    swift_features, max_components=500, step_size=75
)

# Display the elbow plot
elbow_fig.show()

# Apply dimensionality reduction
swift_features_pca, pca_info, scaler_swift = swift_extractor.apply_dimensionality_reduction(
    swift_features, n_components=optimal_components, method='pca'
)

# Apply t-SNE for visualization
swift_features_tsne, tsne_info, _ = swift_extractor.apply_dimensionality_reduction(
    swift_features_pca, n_components=2, method='tsne'
)

# Perform clustering
swift_clustering_results = swift_extractor.perform_clustering(
    swift_features_pca, n_clusters=None, cluster_range=(2, 7)
)

# Create analysis dashboard
swift_dashboard = swift_extractor.create_analysis_dashboard(
    swift_features, swift_features_pca, swift_clustering_results, 
    swift_extractor.processing_times, pca_info=pca_info
)
swift_dashboard.show()

Initializing CLIP model 'ViT-B/32' on cpu...

Model initialized: Using CLIP ViT-B/32 for feature extraction

✅ Feature extraction complete: (1050, 512)
🔍 Finding optimal number of PCA components...
Testing 6 different component counts...

✅ Optimal number of components: 75

Applying PCA to preserve 7500.0% variance...

PCA completed: 73.63% of variance preserved
Applying t-SNE to reduce dimensions to 2...
Warning: t-SNE on 1050 samples may take a long time.

t-SNE completed
🎯 Performing clustering analysis...
Finding optimal number of clusters in range (2, 7)...

Optimal number of clusters: 7 (silhouette score: 0.144)
Performing KMeans clustering with 7 clusters...
Clustering completed: 7 clusters, silhouette score: 0.144

# Compare with categories
swift_analysis_results = swift_extractor.compare_with_categories(
    df=df,
    tsne_features=swift_features_tsne,
    clustering_results=swift_clustering_results
)

# Extract results for comparison
swift_ari = swift_analysis_results['ari_score']

ari_scores['SWIFT'] = swift_ari

# Add to comparison data
if 'ari_scores' not in globals():
    ari_scores = {}

🔍 SWIFT Analysis: Comparing clustering with real product categories...

📊 SWIFT processed 1050 images
📋 Extracted 1050 categories
📂 Unique categories: 7
🎯 Adjusted Rand Index(ARI): -0.0003
🔗 Cluster quality (Silhouette): 0.144
📊 Number of clusters: 7
💡 Interpretation: Poor alignment

🏷️ Category distribution:
   Baby Care: 150 images
   Beauty and Personal Care: 150 images
   Computers: 150 images
   Home Decor & Festive Needs: 150 images
   Home Furnishing: 150 images
   Kitchen & Dining: 150 images
   Watches: 150 images

📊 Creating side-by-side comparison: Real Categories vs SWIFT Clusters...
🔍 SWIFT Side-by-Side Comparison:

from src.scripts.plot_compare_extraction_features import compare_methods

# Get number of categories
num_categories = df['product_category'].nunique()

# Create a dictionary with metrics for each method
methods_data = {
    'VGG16': {
        'ari_score': vgg16_ari,
        'silhouette_score': vgg16_analysis_results['silhouette_score'],
        'pca_dims': deep_features_pca.shape[1],
        'original_dims': deep_features.shape[1],
        'categories': num_categories
    },
    'SWIFT (CLIP)': {
        'ari_score': swift_ari,
        'silhouette_score': swift_clustering_results['silhouette_score'],
        'pca_dims': swift_features_pca.shape[1],
        'original_dims': swift_features.shape[1],
        'categories': num_categories
    }
}

# Create and display the comparison visualization
fig = compare_methods(
    methods_data,
    title='🔍 VGG16 vs SWIFT (CLIP) Features Extraction Performance Comparison'
)
fig.show()

### 5.1 Classical Image Descriptors: SIFT, ORB, SURF

import cv2
import numpy as np
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler

print("🔍 Classical Image Descriptors: SIFT, ORB, SURF\n")
print("=" * 80)

# Initialize detectors
sift = cv2.SIFT_create()
orb = cv2.ORB_create(nfeatures=500)
# Note: SURF requires opencv-contrib-python, using ORB as alternative

# Extract descriptors from first 20 processed images
sample_images = processed_images[:min(20, len(processed_images))]
descriptors_list = {'SIFT': [], 'ORB': []}

for idx, img in enumerate(sample_images):
    # Convert to uint8 if needed (processed_images are float [0,1])
    if img.dtype == np.float32 or img.dtype == np.float64:
        img = (img * 255).astype(np.uint8)
    
    # Convert to grayscale if needed
    if len(img.shape) == 3:
        gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
    else:
        gray = img
    
    # SIFT descriptor extraction
    kp_sift, des_sift = sift.detectAndCompute(gray, None)
    if des_sift is not None:
        descriptors_list['SIFT'].append(des_sift)
    
    # ORB descriptor extraction
    kp_orb, des_orb = orb.detectAndCompute(gray, None)
    if des_orb is not None:
        descriptors_list['ORB'].append(des_orb.astype(np.float32))

print(f"✓ SIFT: {len(descriptors_list['SIFT'])} images with keypoints detected")
print(f"✓ ORB: {len(descriptors_list['ORB'])} images with keypoints detected")

# Create bag-of-visual-words: concatenate all descriptors and cluster
print("\n📦 Building Bag-of-Visual-Words...\n")

# Concatenate all SIFT descriptors
if descriptors_list['SIFT']:
    all_sift_des = np.concatenate(descriptors_list['SIFT'], axis=0)
    print(f"SIFT - Total descriptors: {all_sift_des.shape[0]}, Dimension: {all_sift_des.shape[1]}")
    
    # Cluster into visual words (vocabulary size = 64)
    kmeans_sift = KMeans(n_clusters=64, random_state=42, n_init=10)
    sift_labels = kmeans_sift.fit_predict(all_sift_des)
    
    # Create histogram for each image
    sift_features = []
    for des in descriptors_list['SIFT']:
        labels = kmeans_sift.predict(des)
        hist, _ = np.histogram(labels, bins=np.arange(0, 65))
        sift_features.append(hist)
    sift_features = np.array(sift_features)
    print(f"SIFT Feature Matrix: {sift_features.shape}")

# Concatenate all ORB descriptors
if descriptors_list['ORB']:
    all_orb_des = np.concatenate(descriptors_list['ORB'], axis=0)
    print(f"\nORB - Total descriptors: {all_orb_des.shape[0]}, Dimension: {all_orb_des.shape[1]}")
    
    # Cluster into visual words (vocabulary size = 64)
    kmeans_orb = KMeans(n_clusters=64, random_state=42, n_init=10)
    orb_labels = kmeans_orb.fit_predict(all_orb_des)
    
    # Create histogram for each image
    orb_features = []
    for des in descriptors_list['ORB']:
        labels = kmeans_orb.predict(des)
        hist, _ = np.histogram(labels, bins=np.arange(0, 65))
        orb_features.append(hist)
    orb_features = np.array(orb_features)
    print(f"ORB Feature Matrix: {orb_features.shape}")

print("\n✅ Classical descriptors extraction complete!")
print("   SIFT & ORB vocabularies: 64 visual words each")
print("   → Can be used for image classification with SVM/Random Forest")

🔍 Classical Image Descriptors: SIFT, ORB, SURF

================================================================================

✓ SIFT: 20 images with keypoints detected
✓ ORB: 19 images with keypoints detected

📦 Building Bag-of-Visual-Words...

SIFT - Total descriptors: 4307, Dimension: 128

SIFT Feature Matrix: (20, 64)

ORB - Total descriptors: 5074, Dimension: 32

ORB Feature Matrix: (19, 64)

✅ Classical descriptors extraction complete!
   SIFT & ORB vocabularies: 64 visual words each
   → Can be used for image classification with SVM/Random Forest

import os

# --- 1) Setup ---
image_dir = 'dataset/Flipkart/Images'
print(f"Using image directory: {image_dir}")

# --- 2) Data preparation ---
df_prepared = df.copy()

# keep only rows whose image file exists in image_dir
available_images = set(os.listdir(image_dir))
df_prepared = df_prepared[df_prepared['image'].isin(available_images)].reset_index(drop=True)
print(f"Found {len(df_prepared)} rows with existing image files.")

# full path for each image
df_prepared['image_path'] = df_prepared['image'].apply(lambda img: os.path.join(image_dir, img))

def sample_data(df_in, min_samples=8, samples_per_category=150):
    counts = df_in['product_category'].value_counts()
    valid = counts[counts >= min_samples].index
    df_f = df_in[df_in['product_category'].isin(valid)]
    return df_f.groupby('product_category', group_keys=False).apply(
        lambda x: x.sample(min(len(x), samples_per_category), random_state=42)
    ).reset_index(drop=True)

df_sampled = sample_data(df_prepared, min_samples=8, samples_per_category=150)
print(f"Sampled {len(df_sampled)} items across {df_sampled['product_category'].nunique()} categories.")

Using image directory: dataset/Flipkart/Images
Found 1050 rows with existing image files.
Sampled 1050 items across 7 categories.

import importlib
import src.classes.transfer_learning_classifier_unsupervised as tlcu

# reload the module to pick up code changes
importlib.reload(tlcu)

# import the class after reload
from src.classes.transfer_learning_classifier_unsupervised import TransferLearningClassifierUnsupervised


# --- 3) Unsupervised pipeline (VGG16 whole CNN) ---
image_column = 'image_path'
category_column = 'product_category'

vgg_extractor = TransferLearningClassifierUnsupervised(
    input_shape=(224, 224, 3),
    backbones=['VGG16'],
    use_include_top=False
)

_ = vgg_extractor.prepare_data_from_dataframe(
    df=df_sampled,
    image_column=image_column,
    category_column=category_column,
    image_dir=None  # image_column already has full paths
)
processed_images = vgg_extractor._load_images()

# features
vgg_features = vgg_extractor._extract_features('VGG16')

# elbow
optimal_components, elbow_fig = vgg_extractor.find_optimal_pca_components(
    vgg_features, max_components=500, step_size=75
)
elbow_fig.show()

# PCA
vgg_features_pca, pca_info, scaler_vgg = vgg_extractor.apply_dimensionality_reduction(
    vgg_features, n_components=optimal_components, method='pca'
)

# t-SNE
vgg_features_tsne, tsne_info, _ = vgg_extractor.apply_dimensionality_reduction(
    vgg_features_pca, n_components=2, method='tsne'
)

# clustering
vgg_clustering_results = vgg_extractor.perform_clustering(
    vgg_features_pca, n_clusters=None, cluster_range=(7, 7)
)

# dashboard
vgg_dashboard = vgg_extractor.create_analysis_dashboard(
    backbone_name='VGG16',
    original_features=vgg_features,
    reduced_features=vgg_features_pca,
    clustering_results=vgg_clustering_results,
    processing_times=vgg_extractor.processing_times,
    pca_info=pca_info
)
vgg_dashboard.show()

# compare with categories
vgg_analysis_results = vgg_extractor.compare_with_categories(
    df=vgg_extractor.df,
    tsne_features=vgg_features_tsne,
    clustering_results=vgg_clustering_results,
    backbone_name='VGG16'
)

# ARI
vgg_ari = vgg_analysis_results['ari_score']
if 'ari_scores' not in globals():
    ari_scores = {}
ari_scores['VGG16'] = vgg_ari
print(f"VGG16 ARI: {vgg_ari:.4f}")

Prepared 1050 samples for unsupervised analysis.

Loaded 1050 images for feature extraction.

VGG16 features shape: (1050, 512) (include_top=False)
🔍 Finding optimal number of PCA components...

✅ Optimal number of components: 75

Applying PCA to reduce dimensions from 512 to 75...

PCA completed: 68.11% of variance preserved
Applying t-SNE to reduce dimensions to 2...

t-SNE completed
🎯 Performing clustering analysis...
Finding optimal number of clusters in range (7, 7)...

Optimal number of clusters: 7 (silhouette score: 0.067)
Performing KMeans clustering with 7 clusters...

Clustering completed: 7 clusters, silhouette score: 0.067

🔍 VGG16 Analysis: Comparing clustering with real product categories...

# Create a copy to avoid modifying the original dictionary in place
combined_ari_scores = ari_scores.copy()


# Import existing plotting function
from src.scripts.plot_ari_comparison import ari_comparison

# Create and display the final, combined visualization
print("\n📈 Creating final comparison plot...")
final_comparison_fig = ari_comparison(combined_ari_scores)
final_comparison_fig.show()

📈 Creating final comparison plot...

from src.classes.transfer_learning_classifier import TransferLearningClassifier


# --- 3. Model Training ---

# Initialize classifier with explicit parameters for reproducibility
classifier = TransferLearningClassifier(
    input_shape=(224, 224, 3)
    
)

# Prepare data - the classifier will now receive full, verified paths
data_summary = classifier.prepare_data_from_dataframe(
    df_sampled, 
    image_column='image_path',      # Use the column with full paths
    category_column='product_category',# Use the clean category column
    test_size=0.2,
    val_size=0.25, 
    random_state=42
)
print("\n✅ Data prepared for transfer learning:")
print(f"   🎯 Classes: {data_summary['num_classes']}")
print(f"   Train/Val/Test split: {data_summary['train_size']}/{data_summary['val_size']}/{data_summary['test_size']}")

# Prepare image arrays for training
classifier.prepare_arrays_method()
print("✅ Image arrays prepared for training.")

# Train models with more conservative parameters for stability
print("\n🚀 Training VGG16 models...")

# Base model
base_model = classifier.create_base_model(show_backbone_summary=True)
results1 = classifier.train_model(
    'base_vgg16', 
    base_model, 
    epochs=10,      # Reduced for faster, more stable initial training
    batch_size=8,   # Smaller batch size to prevent memory issues
    patience=3
)

# Augmented model
aug_model = classifier.create_augmented_model()
results2 = classifier.train_model(
    'augmented_vgg16', 
    aug_model, 
    epochs=10,
    batch_size=8,
    patience=3
)
print("✅ Training complete.")

# --- 4. Results and Visualization ---
print("\n📈 Displaying results...")
# Compare models
comparison_fig = classifier.compare_models()
comparison_fig.show()

# Plot training history
history_fig = classifier.plot_training_history()
history_fig.show()

# Plot confusion matrix for the best model
summary = classifier.get_summary()
if summary['best_model']:
    best_model_name = summary['best_model']['name']
    print(f"📊 Plotting confusion matrix for best model: {best_model_name}")
    conf_fig = classifier.plot_confusion_matrix(best_model_name)
    conf_fig.show()

# Print final summary
print("\n📋 Final Summary:")
print(summary)

🔧 Transfer Learning Classifier initialized
   📊 Input shape: (224, 224, 3)
   🎯 GPU Available: 0
🔄 Preparing data from DataFrame...
   📁 Using default image directory: dataset/Flipkart/Images
   📋 Categories found: ['Baby Care', 'Beauty and Personal Care', 'Computers', 'Home Decor & Festive Needs', 'Home Furnishing', 'Kitchen & Dining', 'Watches']
   🎯 Number of classes: 7
   📊 Train samples: 630
   📊 Validation samples: 210
   📊 Test samples: 210

✅ Data prepared for transfer learning:
   🎯 Classes: 7
   Train/Val/Test split: 630/210/210
🔄 Preparing data using arrays method...
   🖼️ Loading 630 images...

   ✅ Successfully loaded 630 images (0 failures)

   🖼️ Loading 210 images...

   ✅ Successfully loaded 210 images (0 failures)
   🖼️ Loading 210 images...

   ✅ Successfully loaded 210 images (0 failures)
   📊 Train set: (630, 224, 224, 3)
   📊 Validation set: (210, 224, 224, 3)
   📊 Test set: (210, 224, 224, 3)
✅ Image arrays prepared for training.

🚀 Training VGG16 models...
🔧 Creating base model with VGG16...

=== Backbone Summary (Frozen) ===

Model: "vgg16"

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
┃ Layer (type)                      ┃ Output Shape             ┃       Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
│ input_layer_2 (InputLayer)        │ (None, 224, 224, 3)      │             0 │
├───────────────────────────────────┼──────────────────────────┼───────────────┤
│ block1_conv1 (Conv2D)             │ (None, 224, 224, 64)     │         1,792 │
├───────────────────────────────────┼──────────────────────────┼───────────────┤
│ block1_conv2 (Conv2D)             │ (None, 224, 224, 64)     │        36,928 │
├───────────────────────────────────┼──────────────────────────┼───────────────┤
│ block1_pool (MaxPooling2D)        │ (None, 112, 112, 64)     │             0 │
├───────────────────────────────────┼──────────────────────────┼───────────────┤
│ block2_conv1 (Conv2D)             │ (None, 112, 112, 128)    │        73,856 │
├───────────────────────────────────┼──────────────────────────┼───────────────┤
│ block2_conv2 (Conv2D)             │ (None, 112, 112, 128)    │       147,584 │
├───────────────────────────────────┼──────────────────────────┼───────────────┤
│ block2_pool (MaxPooling2D)        │ (None, 56, 56, 128)      │             0 │
├───────────────────────────────────┼──────────────────────────┼───────────────┤
│ block3_conv1 (Conv2D)             │ (None, 56, 56, 256)      │       295,168 │
├───────────────────────────────────┼──────────────────────────┼───────────────┤
│ block3_conv2 (Conv2D)             │ (None, 56, 56, 256)      │       590,080 │
├───────────────────────────────────┼──────────────────────────┼───────────────┤
│ block3_conv3 (Conv2D)             │ (None, 56, 56, 256)      │       590,080 │
├───────────────────────────────────┼──────────────────────────┼───────────────┤
│ block3_pool (MaxPooling2D)        │ (None, 28, 28, 256)      │             0 │
├───────────────────────────────────┼──────────────────────────┼───────────────┤
│ block4_conv1 (Conv2D)             │ (None, 28, 28, 512)      │     1,180,160 │
├───────────────────────────────────┼──────────────────────────┼───────────────┤
│ block4_conv2 (Conv2D)             │ (None, 28, 28, 512)      │     2,359,808 │
├───────────────────────────────────┼──────────────────────────┼───────────────┤
│ block4_conv3 (Conv2D)             │ (None, 28, 28, 512)      │     2,359,808 │
├───────────────────────────────────┼──────────────────────────┼───────────────┤
│ block4_pool (MaxPooling2D)        │ (None, 14, 14, 512)      │             0 │
├───────────────────────────────────┼──────────────────────────┼───────────────┤
│ block5_conv1 (Conv2D)             │ (None, 14, 14, 512)      │     2,359,808 │
├───────────────────────────────────┼──────────────────────────┼───────────────┤
│ block5_conv2 (Conv2D)             │ (None, 14, 14, 512)      │     2,359,808 │
├───────────────────────────────────┼──────────────────────────┼───────────────┤
│ block5_conv3 (Conv2D)             │ (None, 14, 14, 512)      │     2,359,808 │
├───────────────────────────────────┼──────────────────────────┼───────────────┤
│ block5_pool (MaxPooling2D)        │ (None, 7, 7, 512)        │             0 │
└───────────────────────────────────┴──────────────────────────┴───────────────┘

 Total params: 14,714,688 (56.13 MB)

 Trainable params: 0 (0.00 B)

# Call the new method to get the interactive plot
example_fig = classifier.plot_prediction_examples(
    model_name=best_model_name,
    num_correct=4,  # Show 4 correct predictions
    num_incorrect=4 # Show 4 incorrect predictions
)


example_fig.show()

🖼️ Visualizing prediction examples for model: base_vgg16

import importlib
import src.classes.enhanced_metrics as em
import numpy as np
import plotly.express as px

# reload the module to pick up any code changes
importlib.reload(em)

from src.classes.enhanced_metrics import EnhancedMetrics 

# Get predictions from best model using only test data
best_model = classifier.models[best_model_name]

# Get test predictions (use preprocessed test images from classifier)
y_pred_probs = best_model.predict(classifier.X_test, verbose=0)
y_pred = np.argmax(y_pred_probs, axis=1)

# Get true labels from test dataframe
y_true_test = classifier.test_df['product_category'].values
category_names = sorted(df_sampled['product_category'].unique())
category_indices = {cat: idx for idx, cat in enumerate(category_names)}
y_true_encoded = np.array([category_indices[cat] for cat in y_true_test])

# Initialize enhanced metrics with predictions
metrics_calc = EnhancedMetrics(y_true=y_true_encoded, y_pred=y_pred, class_names=category_names)

# Get metrics (returns a dictionary)
per_class_metrics = metrics_calc.get_per_class_metrics()
metrics_dict = metrics_calc.get_macro_micro_f1()

# Extract F1 scores from dictionary
macro_f1 = metrics_dict['macro_f1']
micro_f1 = metrics_dict['micro_f1']
weighted_f1 = metrics_dict['weighted_f1']

# Display results
print("📊 Enhanced Metrics Results:")
print(f"✓ Macro F1:    {macro_f1:.4f}")
print(f"✓ Micro F1:    {micro_f1:.4f}")
print(f"✓ Weighted F1: {weighted_f1:.4f}")
print("\n📋 Per-Class Metrics:")
print(per_class_metrics.to_string(index=False))

# Plotly Pie Chart of scores by category
fig_pie = px.pie(per_class_metrics, values='F1-Score', names='Class', 
                 title='F1 Score Distribution by Product Category',
                 hover_data=['Precision', 'Recall'])
fig_pie.update_traces(textposition='inside', textinfo='percent+label')
fig_pie.show()

📊 Enhanced Metrics Results:
✓ Macro F1:    0.7857
✓ Micro F1:    0.7857
✓ Weighted F1: 0.7857

📋 Per-Class Metrics:
                     Class  Precision   Recall  F1-Score  Support
                 Baby Care   0.700000 0.700000  0.700000       30
  Beauty and Personal Care   0.705882 0.800000  0.750000       30
                 Computers   0.862069 0.833333  0.847458       30
Home Decor & Festive Needs   0.700000 0.700000  0.700000       30
           Home Furnishing   0.875000 0.700000  0.777778       30
          Kitchen & Dining   0.781250 0.833333  0.806452       30
                   Watches   0.903226 0.933333  0.918033       30

import importlib
import src.classes.grad_cam as gc

# Reload the module to pick up any code changes
importlib.reload(gc)

from src.classes.grad_cam import GradCAM
import numpy as np
import matplotlib.pyplot as plt

# Initialize Grad-CAM for the best model using the VGG16 layer
model = classifier.models[best_model_name]
grad_cam = GradCAM(model, layer_name='vgg16')

print("🔍 Grad-CAM Visualization: Original | Activation | Overlay\n")
print("=" * 80)

# Get predictions on test set to identify correct and incorrect
y_pred_probs = model.predict(classifier.X_test, verbose=0)
y_pred = np.argmax(y_pred_probs, axis=1)
y_true_test = classifier.test_df['product_category'].values
category_indices = {cat: idx for idx, cat in enumerate(category_names)}
y_true_encoded = np.array([category_indices[cat] for cat in y_true_test])

# Find indices of correct and incorrect predictions
correct_indices = np.where(y_pred == y_true_encoded)[0]
incorrect_indices = np.where(y_pred != y_true_encoded)[0]

# Select 3 correct and 3 incorrect samples
selected_correct = correct_indices[:3] if len(correct_indices) >= 3 else correct_indices
selected_incorrect = incorrect_indices[:3] if len(incorrect_indices) >= 3 else incorrect_indices

# Combine and sort for display
selected_indices = np.concatenate([selected_correct, selected_incorrect])

print(f"\n📸 Grad-CAM Analysis: 3 CORRECT + 3 INCORRECT Predictions\n")
print("=" * 80)

for sample_num, idx in enumerate(selected_indices):
    true_label = y_true_test[idx]
    pred_label = category_names[y_pred[idx]]
    is_correct = true_label == pred_label
    
    # Determine if correct or incorrect
    status = "✓ CORRECT" if is_correct else "✗ INCORRECT"
    label_info = f"True: {true_label} | Predicted: {pred_label}"
    
    print(f"\nSample {sample_num+1}: {status}")
    print(f"  {label_info}")
    print("-" * 80)
    
    # Create Grad-CAM visualization
    test_image = classifier.X_test[idx]
    detail_fig = grad_cam.visualize_single_prediction(
        image=test_image,
        class_names=category_names,
        true_label=true_label
    )
    # Use plt.show() for Matplotlib figures, NOT .show() which is for Plotly
    plt.show()

print("\n" + "=" * 80)
print(f"✓ Analysis complete: {len(selected_correct)} correct, {len(selected_incorrect)} incorrect")

Using layer 'vgg16' for Grad-CAM visualization
🔍 Grad-CAM Visualization: Original | Activation | Overlay

================================================================================

📸 Grad-CAM Analysis: 3 CORRECT + 3 INCORRECT Predictions

================================================================================

Sample 1: ✓ CORRECT
  True: Baby Care | Predicted: Baby Care
--------------------------------------------------------------------------------

Sample 2: ✓ CORRECT
  True: Home Furnishing | Predicted: Home Furnishing
--------------------------------------------------------------------------------

Sample 3: ✓ CORRECT
  True: Beauty and Personal Care | Predicted: Beauty and Personal Care
--------------------------------------------------------------------------------

Sample 4: ✗ INCORRECT
  True: Beauty and Personal Care | Predicted: Kitchen & Dining
--------------------------------------------------------------------------------

Sample 5: ✗ INCORRECT
  True: Home Furnishing | Predicted: Baby Care
--------------------------------------------------------------------------------

Sample 6: ✗ INCORRECT
  True: Kitchen & Dining | Predicted: Home Decor & Festive Needs
--------------------------------------------------------------------------------

================================================================================
✓ Analysis complete: 3 correct, 3 incorrect

from src.classes.multi_seed_trainer import MultiSeedTrainer
import tensorflow as tf
from tensorflow.keras import layers
from tensorflow.keras.applications.vgg16 import VGG16, preprocess_input
import numpy as np

# Extract VGG16 features directly using Keras model
print("🔄 Extracting VGG16 features from classifier images...")

# Load VGG16 without the top classification layer
vgg_model = VGG16(weights='imagenet', include_top=False, input_shape=(224, 224, 3))

# Extract features from train, val, test images (already preprocessed by classifier)
print("Extracting from training images...")
vgg_train_features = vgg_model.predict(classifier.X_train, batch_size=8, verbose=0)
vgg_train_features = vgg_train_features.reshape(vgg_train_features.shape[0], -1)

print("Extracting from validation images...")
vgg_val_features = vgg_model.predict(classifier.X_val, batch_size=8, verbose=0)
vgg_val_features = vgg_val_features.reshape(vgg_val_features.shape[0], -1)

print("Extracting from test images...")
vgg_test_features = vgg_model.predict(classifier.X_test, batch_size=8, verbose=0)
vgg_test_features = vgg_test_features.reshape(vgg_test_features.shape[0], -1)

print(f"✓ VGG16 features extracted:")
print(f"  Train: {vgg_train_features.shape}")
print(f"  Val:   {vgg_val_features.shape}")
print(f"  Test:  {vgg_test_features.shape}")

# Define a model builder function using the correct feature dimension
def build_vgg16_classifier(num_classes=len(category_names), feature_dim=vgg_train_features.shape[1]):
    """Build a simple classifier on top of VGG16 features."""
    model = tf.keras.Sequential([
        layers.Dense(512, activation='relu', input_shape=(feature_dim,)),
        layers.Dropout(0.5),
        layers.Dense(256, activation='relu'),
        layers.Dropout(0.3),
        layers.Dense(num_classes, activation='softmax')
    ])
    model.compile(
        optimizer='adam',
        loss='categorical_crossentropy',
        metrics=['accuracy']
    )
    return model

# Initialize multi-seed trainer with 3 seeds
multi_seed_trainer = MultiSeedTrainer(
    model_builder=build_vgg16_classifier,
    num_seeds=3
)

# Quick multi-seed training demo
print("🌱 Multi-Seed Training Results:\n")

# Get category names and mapping
category_names = sorted(df_sampled['product_category'].unique())
category_indices = {cat: idx for idx, cat in enumerate(category_names)}

# Get labels from the stored dataframes in classifier
y_train = np.array([category_indices[cat] for cat in classifier.train_df['product_category'].values])
y_val = np.array([category_indices[cat] for cat in classifier.val_df['product_category'].values])
y_test = np.array([category_indices[cat] for cat in classifier.test_df['product_category'].values])

# Convert labels to one-hot encoding for model.fit()
from tensorflow.keras.utils import to_categorical
y_train_onehot = to_categorical(y_train, num_classes=len(category_names))
y_val_onehot = to_categorical(y_val, num_classes=len(category_names))
y_test_onehot = to_categorical(y_test, num_classes=len(category_names))

# Run multi-seed training using extracted VGG16 features
results = multi_seed_trainer.run_all_seeds(
    X_train=vgg_train_features,
    y_train=y_train_onehot,
    X_val=vgg_val_features,
    y_val=y_val_onehot,
    X_test=vgg_test_features,
    y_test=y_test_onehot,
    epochs=5,
    batch_size=32
)

# Display aggregated metrics
print(f"\n📊 Aggregated Results Across {multi_seed_trainer.num_seeds} Seeds:")
print(f"Mean Test Accuracy: {results['mean_test_accuracy']:.4f} ± {results['std_test_accuracy']:.4f}")
print(f"Mean Val Accuracy:  {results['mean_val_accuracy']:.4f} ± {results['std_val_accuracy']:.4f}")
print("✓ Models are reproducible and stable!")

# cleanup
del vgg_train_features, vgg_val_features, vgg_test_features
import gc
gc.collect()  # Force garbage collection

🔄 Extracting VGG16 features from classifier images...

Extracting from training images...

Extracting from validation images...

Extracting from test images...

✓ VGG16 features extracted:
  Train: (630, 25088)
  Val:   (210, 25088)
  Test:  (210, 25088)
🌱 Multi-Seed Training Results:


🔄 Starting multi-seed training (3 seeds)...

  Seed 1/3 (seed=42)...

  Test Accuracy: 0.8095

  Seed 2/3 (seed=43)...

  Test Accuracy: 0.8000

  Seed 3/3 (seed=44)...

  Test Accuracy: 0.7952

📊 Aggregated Results Across 3 Seeds:
Mean Test Accuracy: 0.8016 ± 0.0073
Mean Val Accuracy:  0.8143 ± 0.0082
✓ Models are reproducible and stable!

49037

import time
import pandas as pd
import plotly.express as px
import importlib
import src.classes.transfer_learning_classifier as tlc

# Reload the module
importlib.reload(tlc)
from src.classes.transfer_learning_classifier import TransferLearningClassifier

# Define models to compare
models_to_compare = ['VGG16', 'EfficientNetB0', 'MobileNetV3Small']
results_arch = []

print("Starting Architecture Comparison...")

for model_name in tqdm(models_to_compare, desc="Comparing Architectures"):
    print(f"\nTraining {model_name}...")
    
    # Initialize classifier with specific architecture
    # We use a smaller number of epochs for comparison speed
    clf = TransferLearningClassifier(
        input_shape=(224, 224, 3),
        base_model_name=model_name
    )
    
    # Prepare data (reuse df_sampled from previous cells)
    # We also need to pass the correct column names.
    clf.prepare_data_from_dataframe(
        df=df_sampled,
        image_column='image_path',
        category_column='product_category',
        test_size=0.2,
        val_size=0.25
    )
    
    # Prepare arrays (load images)
    clf.prepare_arrays_method()
    
    # Create model
    model = clf.create_base_model()
    
    # Train
    train_results = clf.train_model(
        model_name=f"{model_name}_comparison",
        model=model,
        epochs=5,
        batch_size=32,
        patience=2
    )
    
    # Get evaluation results
    # train_model stores results in clf.evaluation_results
    eval_res = clf.evaluation_results.get(f"{model_name}_comparison", {})
    acc = eval_res.get('accuracy', 0)
    training_time = eval_res.get('training_time', 0)
    
    results_arch.append({
        'Model': model_name,
        'Accuracy': acc,
        'Training Time (s)': training_time,
        'Parameters': model.count_params()
    })
    print(f"{model_name} - Accuracy: {acc:.4f}, Time: {training_time:.2f}s")

# Create comparison dataframe
comp_df = pd.DataFrame(results_arch)

# Visualize Accuracy
fig_acc = px.bar(comp_df, x='Model', y='Accuracy', 
                 title='Model Accuracy Comparison',
                 color='Model', text_auto='.4f')
fig_acc.show()

# Visualize Training Time
fig_time = px.bar(comp_df, x='Model', y='Training Time (s)', 
                  title='Training Time Comparison (5 Epochs)',
                  color='Model', text_auto='.2f')
fig_time.show()

# Visualize Efficiency (Accuracy per Second)
comp_df['Efficiency'] = comp_df['Accuracy'] / comp_df['Training Time (s)']
fig_eff = px.scatter(comp_df, x='Training Time (s)', y='Accuracy', 
                     size='Parameters', color='Model',
                     title='Accuracy vs Training Time (Size = Parameters)',
                     hover_data=['Parameters'])
fig_eff.show()

print("\nComparison Results:")
print(comp_df)

Starting Architecture Comparison...

Training VGG16...
🔧 Transfer Learning Classifier initialized
   📊 Input shape: (224, 224, 3)
   🎯 GPU Available: 0
🔄 Preparing data from DataFrame...
   📁 Using default image directory: dataset/Flipkart/Images
   📋 Categories found: ['Baby Care', 'Beauty and Personal Care', 'Computers', 'Home Decor & Festive Needs', 'Home Furnishing', 'Kitchen & Dining', 'Watches']
   🎯 Number of classes: 7
   📊 Train samples: 630
   📊 Validation samples: 210
   📊 Test samples: 210
🔄 Preparing data using arrays method...
   🖼️ Loading 630 images...

   ✅ Successfully loaded 630 images (0 failures)

   🖼️ Loading 210 images...

   ✅ Successfully loaded 210 images (0 failures)
   🖼️ Loading 210 images...

   ✅ Successfully loaded 210 images (0 failures)
   📊 Train set: (630, 224, 224, 3)
   📊 Validation set: (210, 224, 224, 3)
   📊 Test set: (210, 224, 224, 3)
🔧 Creating base model with VGG16...

   ✅ Base model created and compiled.

Model: "functional_6"

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
│ input_layer_11 (InputLayer)     │ (None, 224, 224, 3)    │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ vgg16 (Functional)              │ (None, 7, 7, 512)      │    14,714,688 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ global_average_pooling2d_3      │ (None, 512)            │             0 │
│ (GlobalAveragePooling2D)        │                        │               │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dense_13 (Dense)                │ (None, 1024)           │       525,312 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dropout_8 (Dropout)             │ (None, 1024)           │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dense_14 (Dense)                │ (None, 7)              │         7,175 │
└─────────────────────────────────┴────────────────────────┴───────────────┘

 Total params: 15,247,175 (58.16 MB)

from src.classes.multimodal_analysis import MultimodalAnalysis

# Initialize multimodal analysis
multimodal = MultimodalAnalysis(classifier)

# Run fusion analysis (Text + Image)
# This reuses the best text model (USE) and image model (VGG16)
fusion_metrics = multimodal.evaluate_fusion(
    classifier.X_test,
    classifier.test_df['product_category'].values,
    classifier.test_df['description'].values
)

Extracting image features...

Extracting text features...
   📦 Using cached model directory: /app/cache/use_model
   ⏳ Loading Universal Sentence Encoder (this is a one-time download)...

   ✅ Model loaded successfully!

Training simple classifier on fused features (80/20 split of provided data)...

✓ Image-only (SVM on VGG features): 0.7143
✓ Fusion (Text+Image): 0.8571
✓ Fusion F1 Score: 0.8624
✓ Improvement: +20.0%

from src.classes.mlflow_tracker import MLflowTracker
import mlflow

# Initialize MLflow tracker (without run_name)
mlflow_tracker = MLflowTracker(
    experiment_name="Mission6_Advanced_Improvements"
)

# Ensure any previous run is ended before starting a new one
if mlflow.active_run():
    print(f"⚠️ Ending active run: {mlflow.active_run().info.run_id}")
    mlflow.end_run()

# Log experiment with ACTUAL metrics from your analyses
print("📝 MLflow Tracking Demo:\n")

# Start a run with the run_name parameter
mlflow_tracker.start_run(run_name="Demo_Run2")

# Log parameters (use log_params, not log_parameters)
mlflow_tracker.log_params({
    'backbone': 'VGG16',
    'fusion_method': 'late',
    'multi_seed_count': multi_seed_trainer.num_seeds,
    'epochs': 5,
    'batch_size': 32
})

# Log ACTUAL metrics from earlier sections
# Use variables from previous cells if they exist, else default to 0
single_modality_acc = comp_df[comp_df['Model'] == 'VGG16']['Accuracy'].values[0] if 'comp_df' in locals() and not comp_df.empty else 0

# Use 'fusion_accuracy' instead of 'test_accuracy'
fusion_acc = fusion_metrics['fusion_accuracy'] if 'fusion_metrics' in locals() else 0

ms_mean = results['mean_test_accuracy'] if 'results' in locals() else 0
ms_std = results['std_test_accuracy'] if 'results' in locals() else 0

mlflow_tracker.log_metrics({
    'best_model_accuracy': single_modality_acc,
    'macro_f1': macro_f1 if 'macro_f1' in locals() else 0,
    'micro_f1': micro_f1 if 'micro_f1' in locals() else 0,
    'weighted_f1': weighted_f1 if 'weighted_f1' in locals() else 0,
    'fusion_test_accuracy': fusion_acc,
    'multi_seed_mean_test_accuracy': ms_mean,
    'multi_seed_std_test_accuracy': ms_std,
})

# Register model
mlflow_tracker.log_model(
    model=classifier.models[best_model_name],
    artifact_path='VGG16_Transfer_Learning'
)

# End the run
mlflow_tracker.end_run()

print("✓ Experiment logged to MLflow!")
print(f"  Logged metrics:")
print(f"    - Best Model Accuracy: {single_modality_acc:.4f}")
print(f"    - Macro F1: {macro_f1 if 'macro_f1' in locals() else 0:.4f}")
print(f"    - Fusion Test Accuracy: {fusion_acc:.4f}")
print(f"    - Multi-Seed Mean ± Std: {ms_mean:.4f} ± {ms_std:.4f}")
print("  Use 'mlflow ui' to view dashboard")

✅ MLflow experiment: Mission6_Advanced_Improvements
📝 MLflow Tracking Demo:

✅ Started MLflow run: 57753e234c034c5fb33104c6bf6bf1d7
✅ Logged 5 parameters

2025/12/28 23:40:48 WARNING mlflow.models.model: `artifact_path` is deprecated. Please use `name` instead.

2025/12/28 23:40:49 WARNING mlflow.keras.save: You are saving a Keras model without specifying model signature.

✅ Logged model to VGG16_Transfer_Learning
✅ Ended MLflow run: 57753e234c034c5fb33104c6bf6bf1d7
✓ Experiment logged to MLflow!
  Logged metrics:
    - Best Model Accuracy: 0.7952
    - Macro F1: 0.7857
    - Fusion Test Accuracy: 0.8571
    - Multi-Seed Mean ± Std: 0.8016 ± 0.0073
  Use 'mlflow ui' to view dashboard

Modality	Description	Source	Notes
Images	Product photos (RGB)	Flipkart dataset	Variable resolutions; resized to 224×224
Text	Product titles / descriptions (English)	Metadata CSV	Cleaned: lowercased, punctuation stripped, stopwords partially removed
Labels	Product category identifiers	Metadata CSV	Multi-class (N classes)

	uniq_id	crawl_timestamp	product_url	product_name	product_category_tree	pid	retail_price	discounted_price	image	is_FK_Advantage_product	description	product_rating	overall_rating	brand	product_specifications
0	55b85ea15a1536d46b7190ad6fff8ce7	2016-04-30 03:22:56 +0000	http://www.flipkart.com/elegance-polyester-mul...	Elegance Polyester Multicolor Abstract Eyelet ...	["Home Furnishing >> Curtains & Accessories >>...	CRNEG7BKMFFYHQ8Z	1899.0	899.0	55b85ea15a1536d46b7190ad6fff8ce7.jpg	False	Key Features of Elegance Polyester Multicolor ...	No rating available	No rating available	Elegance	{"product_specification"=>[{"key"=>"Brand", "v...
1	7b72c92c2f6c40268628ec5f14c6d590	2016-04-30 03:22:56 +0000	http://www.flipkart.com/sathiyas-cotton-bath-t...	Sathiyas Cotton Bath Towel	["Baby Care >> Baby Bath & Skin >> Baby Bath T...	BTWEGFZHGBXPHZUH	600.0	449.0	7b72c92c2f6c40268628ec5f14c6d590.jpg	False	Specifications of Sathiyas Cotton Bath Towel (...	No rating available	No rating available	Sathiyas	{"product_specification"=>[{"key"=>"Machine Wa...
2	64d5d4a258243731dc7bbb1eef49ad74	2016-04-30 03:22:56 +0000	http://www.flipkart.com/eurospa-cotton-terry-f...	Eurospa Cotton Terry Face Towel Set	["Baby Care >> Baby Bath & Skin >> Baby Bath T...	BTWEG6SHXTDB2A2Y	NaN	NaN	64d5d4a258243731dc7bbb1eef49ad74.jpg	False	Key Features of Eurospa Cotton Terry Face Towe...	No rating available	No rating available	Eurospa	{"product_specification"=>[{"key"=>"Material",...
3	d4684dcdc759dd9cdf41504698d737d8	2016-06-20 08:49:52 +0000	http://www.flipkart.com/santosh-royal-fashion-...	SANTOSH ROYAL FASHION Cotton Printed King size...	["Home Furnishing >> Bed Linen >> Bedsheets >>...	BDSEJT9UQWHDUBH4	2699.0	1299.0	d4684dcdc759dd9cdf41504698d737d8.jpg	False	Key Features of SANTOSH ROYAL FASHION Cotton P...	No rating available	No rating available	SANTOSH ROYAL FASHION	{"product_specification"=>[{"key"=>"Brand", "v...
4	6325b6870c54cd47be6ebfbffa620ec7	2016-06-20 08:49:52 +0000	http://www.flipkart.com/jaipur-print-cotton-fl...	Jaipur Print Cotton Floral King sized Double B...	["Home Furnishing >> Bed Linen >> Bedsheets >>...	BDSEJTHNGWVGWWQU	2599.0	698.0	6325b6870c54cd47be6ebfbffa620ec7.jpg	False	Key Features of Jaipur Print Cotton Floral Kin...	No rating available	No rating available	Jaipur Print	{"product_specification"=>[{"key"=>"Machine Wa...

	key	value	count	percentage	total_occurrences
0	Type	Analog	123	16.90	728
1	Type	Mug	74	10.16	728
2	Type	Ethnic	56	7.69	728
3	Type	Wireless Without modem	27	3.71	728
4	Type	Religious Idols	26	3.57	728
5	Brand	Lapguard	11	1.94	568
6	Brand	PRINT SHAPES	11	1.94	568
7	Brand	Lal Haveli	10	1.76	568
8	Brand	Raymond	8	1.41	568
9	Brand	Aroma Comfort	8	1.41	568
10	Sales Package	1 Mug	49	9.59	511
11	Sales Package	1 Showpiece Figurine	44	8.61	511
12	Sales Package	1 mug	22	4.31	511
13	Sales Package	Blanket	12	2.35	511
14	Sales Package	1 Laptop Adapter	10	1.96	511
15	Color	Multicolor	98	19.41	505
16	Color	Black	73	14.46	505
17	Color	White	42	8.32	505
18	Color	Blue	31	6.14	505
19	Color	Gold	28	5.54	505
20	Ideal For	Men	88	18.80	468
21	Ideal For	Women	75	16.03	468
22	Ideal For	Men, Women	47	10.04	468
23	Ideal For	Baby Girl's	46	9.83	468
24	Ideal For	Men and Women	35	7.48	468

	Original	Lemmatized	Stemmed
0	Elegance Polyester Multicolor Abstract Eyelet ...	elegance polyester multicolor abstract eyelet ...	eleg polyest multicolor abstract eyelet door c...
1	Sathiyas Cotton Bath Towel	sathiyas cotton bath towel	sathiya cotton bath towel
2	Eurospa Cotton Terry Face Towel Set	eurospa cotton terry face towel set	eurospa cotton terri face towel set
3	SANTOSH ROYAL FASHION Cotton Printed King size...	santosh royal fashion cotton printed king size...	santosh royal fashion cotton print king size d...
4	Jaipur Print Cotton Floral King sized Double B...	jaipur print cotton floral king sized double b...	jaipur print cotton floral king size doubl bed...

Mission 6: Feasibility Study of Product Classification Engine¶

1. Introduction¶

2. Data Overview¶

2.1 Components¶

2.2 Basic Statistics¶

2.3 Class Balance (Post-Filtering)¶

3. Basic NLP Classification Feasibility Study¶

3.1 Text Preprocessing¶

3.2 Basic Text Encoding¶

3.3 Dimensionality Reduction & Visualization¶

3.4 Dimensionality Reduction Conclusion¶

4. Advanced NLP Classification Feasibility Study¶

4.0 Data IP Rights & Copyright Verification¶

4.1 Word Embeddings¶

4.2 Comparative Analysis¶

5. Basic Image Processing Classification Study¶

5.3 Image Data IP Rights & Copyright Verification¶

5.4 Image Feature Extraction & Clustering – Conclusion¶

6. Transfer Learning VGG16 unsupervised¶

6.0 Dimensionality Reduction Parameter Justification¶

7. Transfer Learning (VGG16)¶

8. Advanced Improvements: Production-Ready Features¶

8.1 Enhanced Metrics: Per-Class & Aggregate¶

8.2 Grad-CAM Visualization: Model Interpretability¶

8.3 Multi-Seed Training: Reproducibility & Stability¶

8.4 Alternative Backbones: Architecture Diversity¶

8.5 Multimodal Fusion: Text + Image Late Fusion¶

8.6 MLflow Tracking: Experiment Logging¶

Part 9: Conclusion¶

Key Findings:¶

Future Work:¶